//! 网络流抽象trait
//! 
//! 定义与具体网络实现（如Tokio、QUIC、TLS等）解耦的统一接口
//! 这个trait放在core模块中，供协议层和网络层共同依赖

use std::io;
use async_trait::async_trait;

/// 同步网络流抽象trait（向后兼容）
/// 
/// 保持原有的同步接口不变，确保现有代码可以正常编译
pub trait NetworkStream: Send + Sync + std::fmt::Debug + 'static {
    /// 读取数据到缓冲区
    /// 返回读取的字节数，0表示连接关闭
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;
    
    /// 写入数据
    /// 返回写入的字节数
    fn write(&mut self, buf: &[u8]) -> io::Result<usize>;
    
    /// 刷新缓冲区，确保数据发送
    fn flush(&mut self) -> io::Result<()>;
    
    /// 检查连接是否仍然有效
    fn is_connected(&self) -> bool;
    
    /// 获取远程地址（用于日志和调试）
    fn remote_addr(&self) -> Option<String>;
    
    /// 优雅关闭连接
    fn shutdown(&mut self) -> io::Result<()>;
    
    /// 获取网络类型标识（TCP/QUIC/TLS等）
    fn network_type(&self) -> &'static str;
}

/// 异步网络流抽象trait
/// 
/// 新的异步接口，用于支持真正的异步I/O操作
#[async_trait]
pub trait AsyncNetworkStream: Send + Sync + std::fmt::Debug + 'static {
    /// 异步读取数据到缓冲区
    /// 返回读取的字节数，0表示连接关闭
    async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;
    
    /// 异步写入数据
    /// 返回写入的字节数
    async fn write(&mut self, buf: &[u8]) -> io::Result<usize>;
    
    /// 异步刷新缓冲区，确保数据发送
    async fn flush(&mut self) -> io::Result<()>;
    
    /// 检查连接是否仍然有效
    fn is_connected(&self) -> bool;
    
    /// 获取远程地址（用于日志和调试）
    fn remote_addr(&self) -> Option<String>;
    
    /// 异步优雅关闭连接
    async fn shutdown(&mut self) -> io::Result<()>;
    
    /// 获取网络类型标识（TCP/QUIC/TLS等）
    fn network_type(&self) -> &'static str;
}

/// 标准 TCP 流适配器（使用标准库）
#[derive(Debug)]
pub struct TcpStreamAdapter {
    stream: std::net::TcpStream,
    remote_addr: Option<String>,
}

impl TcpStreamAdapter {
    /// 创建新的TCP流适配器
    pub fn new(stream: std::net::TcpStream) -> io::Result<Self> {
        let remote_addr = stream.peer_addr()
            .map(|addr| addr.to_string())
            .ok();
            
        // 设置为阻塞模式（协议层同步处理）
        stream.set_nonblocking(false)?;
        
        Ok(Self {
            stream,
            remote_addr,
        })
    }
    
    /// 从地址创建TCP连接
    pub fn connect(addr: &str) -> io::Result<Self> {
        let stream = std::net::TcpStream::connect(addr)?;
        Self::new(stream)
    }
}

impl NetworkStream for TcpStreamAdapter {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        use std::io::Read;
        self.stream.read(buf)
    }
    
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        use std::io::Write;
        self.stream.write(buf)
    }
    
    fn flush(&mut self) -> io::Result<()> {
        use std::io::Write;
        self.stream.flush()
    }
    
    fn is_connected(&self) -> bool {
        // 简单检查：尝试获取peer地址
        self.stream.peer_addr().is_ok()
    }
    
    fn remote_addr(&self) -> Option<String> {
        self.remote_addr.clone()
    }
    
    fn shutdown(&mut self) -> io::Result<()> {
        self.stream.shutdown(std::net::Shutdown::Both)
    }
    
    fn network_type(&self) -> &'static str {
        "TCP"
    }
}

